home *** CD-ROM | disk | FTP | other *** search
/ Champak 141 / (Vol 141) Oct 17 2011.iso / Games / Clueless.swf / scripts / fl / video / CuePointManager.as < prev    next >
Encoding:
Text File  |  2011-10-17  |  32.8 KB  |  906 lines
  1. package fl.video
  2. {
  3.    use namespace flvplayback_internal;
  4.    
  5.    public class CuePointManager
  6.    {
  7.       
  8.       public static const SHORT_VERSION:String = "2.1";
  9.       
  10.       public static const VERSION:String = "2.1.0.14";
  11.       
  12.       flvplayback_internal static const DEFAULT_LINEAR_SEARCH_TOLERANCE:Number = 50;
  13.       
  14.       flvplayback_internal static var cuePointsReplace:Array = [""","\"","'","\'",",",",","&","&"];
  15.        
  16.       
  17.       flvplayback_internal var _disabledCuePointsByNameOnly:Object;
  18.       
  19.       flvplayback_internal var navCuePoints:Array;
  20.       
  21.       flvplayback_internal var allCuePoints:Array;
  22.       
  23.       flvplayback_internal var _disabledCuePoints:Array;
  24.       
  25.       flvplayback_internal var _asCuePointTolerance:Number;
  26.       
  27.       flvplayback_internal var _linearSearchTolerance:Number;
  28.       
  29.       flvplayback_internal var _asCuePointIndex:int;
  30.       
  31.       flvplayback_internal var asCuePoints:Array;
  32.       
  33.       flvplayback_internal var flvCuePoints:Array;
  34.       
  35.       flvplayback_internal var _metadataLoaded:Boolean;
  36.       
  37.       flvplayback_internal var _id:uint;
  38.       
  39.       private var _owner:FLVPlayback;
  40.       
  41.       flvplayback_internal var eventCuePoints:Array;
  42.       
  43.       public function CuePointManager(param1:FLVPlayback, param2:uint)
  44.       {
  45.          super();
  46.          _owner = param1;
  47.          flvplayback_internal::_id = param2;
  48.          reset();
  49.          flvplayback_internal::_asCuePointTolerance = _owner.getVideoPlayer(flvplayback_internal::_id).playheadUpdateInterval / 2000;
  50.          flvplayback_internal::_linearSearchTolerance = flvplayback_internal::DEFAULT_LINEAR_SEARCH_TOLERANCE;
  51.       }
  52.       
  53.       flvplayback_internal static function deepCopyObject(param1:Object, param2:uint = 0) : Object
  54.       {
  55.          var _loc3_:Object = null;
  56.          var _loc4_:* = undefined;
  57.          if(param1 == null)
  58.          {
  59.             return param1;
  60.          }
  61.          _loc3_ = new Object();
  62.          for(_loc4_ in param1)
  63.          {
  64.             if(!(param2 == 0 && (_loc4_ == "array" || _loc4_ == "index")))
  65.             {
  66.                if(typeof param1[_loc4_] == "object")
  67.                {
  68.                   _loc3_[_loc4_] = flvplayback_internal::deepCopyObject(param1[_loc4_],param2 + 1);
  69.                }
  70.                else
  71.                {
  72.                   _loc3_[_loc4_] = param1[_loc4_];
  73.                }
  74.             }
  75.          }
  76.          return _loc3_;
  77.       }
  78.       
  79.       flvplayback_internal static function cuePointCompare(param1:Number, param2:String, param3:Object) : int
  80.       {
  81.          var _loc4_:Number = NaN;
  82.          var _loc5_:Number = NaN;
  83.          _loc4_ = Math.round(param1 * 1000);
  84.          _loc5_ = Math.round(param3.time * 1000);
  85.          if(_loc4_ < _loc5_)
  86.          {
  87.             return -1;
  88.          }
  89.          if(_loc4_ > _loc5_)
  90.          {
  91.             return 1;
  92.          }
  93.          if(param2 != null)
  94.          {
  95.             if(param2 == param3.name)
  96.             {
  97.                return 0;
  98.             }
  99.             if(param2 < param3.name)
  100.             {
  101.                return -1;
  102.             }
  103.             return 1;
  104.          }
  105.          return 0;
  106.       }
  107.       
  108.       flvplayback_internal function getCuePoint(param1:Array, param2:Boolean, param3:*) : Object
  109.       {
  110.          var _loc4_:Object = null;
  111.          var _loc5_:int = 0;
  112.          switch(typeof param3)
  113.          {
  114.             case "string":
  115.                _loc4_ = {"name":param3};
  116.                break;
  117.             case "number":
  118.                _loc4_ = {"time":param3};
  119.                break;
  120.             case "object":
  121.                _loc4_ = param3;
  122.          }
  123.          if((_loc5_ = flvplayback_internal::getCuePointIndex(param1,param2,_loc4_.time,_loc4_.name)) < 0)
  124.          {
  125.             return null;
  126.          }
  127.          (_loc4_ = flvplayback_internal::deepCopyObject(param1[_loc5_])).array = param1;
  128.          _loc4_.index = _loc5_;
  129.          return _loc4_;
  130.       }
  131.       
  132.       public function resetASCuePointIndex(param1:Number) : void
  133.       {
  134.          var _loc2_:int = 0;
  135.          if(param1 <= 0 || flvplayback_internal::asCuePoints == null)
  136.          {
  137.             flvplayback_internal::_asCuePointIndex = 0;
  138.             return;
  139.          }
  140.          _loc2_ = flvplayback_internal::getCuePointIndex(flvplayback_internal::asCuePoints,true,param1);
  141.          flvplayback_internal::_asCuePointIndex = flvplayback_internal::asCuePoints[_loc2_].time < param1 ? _loc2_ + 1 : _loc2_;
  142.       }
  143.       
  144.       public function set playheadUpdateInterval(param1:Number) : void
  145.       {
  146.          flvplayback_internal::_asCuePointTolerance = param1 / 2000;
  147.       }
  148.       
  149.       flvplayback_internal function addOrDisable(param1:Boolean, param2:Object) : void
  150.       {
  151.          if(param1)
  152.          {
  153.             if(param2.type == CuePointType.ACTIONSCRIPT)
  154.             {
  155.                throw new VideoError(VideoError.ILLEGAL_CUE_POINT,"Cannot disable actionscript cue points");
  156.             }
  157.             setFLVCuePointEnabled(false,param2);
  158.          }
  159.          else if(param2.type == CuePointType.ACTIONSCRIPT)
  160.          {
  161.             addASCuePoint(param2);
  162.          }
  163.       }
  164.       
  165.       public function processFLVCuePoints(param1:Array) : void
  166.       {
  167.          var _loc2_:int = 0;
  168.          var _loc3_:Number = NaN;
  169.          var _loc4_:Object = null;
  170.          var _loc5_:Array = null;
  171.          var _loc6_:Number = NaN;
  172.          var _loc7_:int = 0;
  173.          flvplayback_internal::_metadataLoaded = true;
  174.          if(param1 == null || param1.length < 1)
  175.          {
  176.             flvplayback_internal::flvCuePoints = null;
  177.             flvplayback_internal::navCuePoints = null;
  178.             flvplayback_internal::eventCuePoints = null;
  179.             return;
  180.          }
  181.          flvplayback_internal::flvCuePoints = param1;
  182.          flvplayback_internal::navCuePoints = new Array();
  183.          flvplayback_internal::eventCuePoints = new Array();
  184.          _loc3_ = -1;
  185.          _loc5_ = flvplayback_internal::_disabledCuePoints;
  186.          _loc6_ = 0;
  187.          flvplayback_internal::_disabledCuePoints = new Array();
  188.          _loc7_ = 0;
  189.          while((_loc4_ = flvplayback_internal::flvCuePoints[_loc7_++]) != undefined)
  190.          {
  191.             if(_loc3_ > 0 && _loc3_ >= _loc4_.time)
  192.             {
  193.                flvplayback_internal::flvCuePoints = null;
  194.                flvplayback_internal::navCuePoints = null;
  195.                flvplayback_internal::eventCuePoints = null;
  196.                flvplayback_internal::_disabledCuePoints = new Array();
  197.                flvplayback_internal::_disabledCuePointsByNameOnly = new Object();
  198.                throw new VideoError(VideoError.ILLEGAL_CUE_POINT,"Unsorted cuePoint found after time: " + _loc3_);
  199.             }
  200.             _loc3_ = Number(_loc4_.time);
  201.             while(_loc6_ < _loc5_.length && flvplayback_internal::cuePointCompare(_loc5_[_loc6_].time,null,_loc4_) < 0)
  202.             {
  203.                _loc6_++;
  204.             }
  205.             if(flvplayback_internal::_disabledCuePointsByNameOnly[_loc4_.name] != undefined || _loc6_ < _loc5_.length && flvplayback_internal::cuePointCompare(_loc5_[_loc6_].time,_loc5_[_loc6_].name,_loc4_) == 0)
  206.             {
  207.                flvplayback_internal::_disabledCuePoints.push({
  208.                   "time":_loc4_.time,
  209.                   "name":_loc4_.name
  210.                });
  211.             }
  212.             if(_loc4_.type == CuePointType.NAVIGATION)
  213.             {
  214.                flvplayback_internal::navCuePoints.push(_loc4_);
  215.             }
  216.             else if(_loc4_.type == CuePointType.EVENT)
  217.             {
  218.                flvplayback_internal::eventCuePoints.push(_loc4_);
  219.             }
  220.             if(flvplayback_internal::allCuePoints == null || flvplayback_internal::allCuePoints.length < 1)
  221.             {
  222.                flvplayback_internal::allCuePoints = new Array();
  223.                flvplayback_internal::allCuePoints.push(_loc4_);
  224.             }
  225.             else
  226.             {
  227.                _loc2_ = flvplayback_internal::getCuePointIndex(flvplayback_internal::allCuePoints,true,_loc4_.time);
  228.                _loc2_ = flvplayback_internal::allCuePoints[_loc2_].time > _loc4_.time ? 0 : _loc2_ + 1;
  229.                flvplayback_internal::allCuePoints.splice(_loc2_,0,_loc4_);
  230.             }
  231.          }
  232.          flvplayback_internal::_disabledCuePointsByNameOnly = new Object();
  233.       }
  234.       
  235.       public function addASCuePoint(param1:*, param2:String = null, param3:Object = null) : Object
  236.       {
  237.          var _loc4_:Object = null;
  238.          var _loc5_:Boolean = false;
  239.          var _loc6_:* = false;
  240.          var _loc7_:int = 0;
  241.          var _loc8_:Number = NaN;
  242.          var _loc9_:Object = null;
  243.          var _loc10_:int = 0;
  244.          if(typeof param1 == "object")
  245.          {
  246.             _loc4_ = flvplayback_internal::deepCopyObject(param1);
  247.          }
  248.          else
  249.          {
  250.             _loc4_ = {
  251.                "time":param1,
  252.                "name":param2,
  253.                "parameters":flvplayback_internal::deepCopyObject(param3)
  254.             };
  255.          }
  256.          if(_loc4_.parameters == null)
  257.          {
  258.             delete _loc4_.parameters;
  259.          }
  260.          if(_loc5_ = isNaN(_loc4_.time) || _loc4_.time < 0)
  261.          {
  262.             throw new VideoError(VideoError.ILLEGAL_CUE_POINT,"time must be number");
  263.          }
  264.          if(_loc6_ = _loc4_.name == null)
  265.          {
  266.             throw new VideoError(VideoError.ILLEGAL_CUE_POINT,"name cannot be undefined or null");
  267.          }
  268.          _loc4_.type = CuePointType.ACTIONSCRIPT;
  269.          if(flvplayback_internal::asCuePoints == null || flvplayback_internal::asCuePoints.length < 1)
  270.          {
  271.             _loc7_ = 0;
  272.             flvplayback_internal::asCuePoints = new Array();
  273.             flvplayback_internal::asCuePoints.push(_loc4_);
  274.          }
  275.          else
  276.          {
  277.             _loc7_ = flvplayback_internal::getCuePointIndex(flvplayback_internal::asCuePoints,true,_loc4_.time);
  278.             _loc7_ = flvplayback_internal::asCuePoints[_loc7_].time > _loc4_.time ? 0 : _loc7_ + 1;
  279.             flvplayback_internal::asCuePoints.splice(_loc7_,0,_loc4_);
  280.          }
  281.          if(flvplayback_internal::allCuePoints == null || flvplayback_internal::allCuePoints.length < 1)
  282.          {
  283.             flvplayback_internal::allCuePoints = new Array();
  284.             flvplayback_internal::allCuePoints.push(_loc4_);
  285.          }
  286.          else
  287.          {
  288.             _loc10_ = flvplayback_internal::getCuePointIndex(flvplayback_internal::allCuePoints,true,_loc4_.time);
  289.             _loc10_ = flvplayback_internal::allCuePoints[_loc10_].time > _loc4_.time ? 0 : _loc10_ + 1;
  290.             flvplayback_internal::allCuePoints.splice(_loc10_,0,_loc4_);
  291.          }
  292.          if((_loc8_ = _owner.getVideoPlayer(flvplayback_internal::_id).playheadTime) > 0)
  293.          {
  294.             if(flvplayback_internal::_asCuePointIndex == _loc7_)
  295.             {
  296.                if(_loc8_ > flvplayback_internal::asCuePoints[_loc7_].time)
  297.                {
  298.                   ++flvplayback_internal::_asCuePointIndex;
  299.                }
  300.             }
  301.             else if(flvplayback_internal::_asCuePointIndex > _loc7_)
  302.             {
  303.                ++flvplayback_internal::_asCuePointIndex;
  304.             }
  305.          }
  306.          else
  307.          {
  308.             flvplayback_internal::_asCuePointIndex = 0;
  309.          }
  310.          (_loc9_ = flvplayback_internal::deepCopyObject(flvplayback_internal::asCuePoints[_loc7_])).array = flvplayback_internal::asCuePoints;
  311.          _loc9_.index = _loc7_;
  312.          return _loc9_;
  313.       }
  314.       
  315.       public function get metadataLoaded() : Boolean
  316.       {
  317.          return flvplayback_internal::_metadataLoaded;
  318.       }
  319.       
  320.       public function reset() : void
  321.       {
  322.          flvplayback_internal::_metadataLoaded = false;
  323.          flvplayback_internal::allCuePoints = null;
  324.          flvplayback_internal::asCuePoints = null;
  325.          flvplayback_internal::_disabledCuePoints = new Array();
  326.          flvplayback_internal::_disabledCuePointsByNameOnly = new Object();
  327.          flvplayback_internal::flvCuePoints = null;
  328.          flvplayback_internal::navCuePoints = null;
  329.          flvplayback_internal::eventCuePoints = null;
  330.          flvplayback_internal::_asCuePointIndex = 0;
  331.       }
  332.       
  333.       public function removeCuePoints(param1:Array, param2:Object) : Number
  334.       {
  335.          var _loc3_:int = 0;
  336.          var _loc4_:Object = null;
  337.          var _loc5_:int = 0;
  338.          _loc5_ = 0;
  339.          _loc3_ = flvplayback_internal::getCuePointIndex(param1,true,-1,param2.name);
  340.          while(_loc3_ >= 0)
  341.          {
  342.             _loc4_ = param1[_loc3_];
  343.             param1.splice(_loc3_,1);
  344.             _loc3_--;
  345.             _loc5_++;
  346.             _loc3_ = flvplayback_internal::getNextCuePointIndexWithName(_loc4_.name,param1,_loc3_);
  347.          }
  348.          return _loc5_;
  349.       }
  350.       
  351.       flvplayback_internal function unescape(param1:String) : String
  352.       {
  353.          var _loc2_:String = null;
  354.          var _loc3_:int = 0;
  355.          _loc2_ = param1;
  356.          _loc3_ = 0;
  357.          while(_loc3_ < flvplayback_internal::cuePointsReplace.length)
  358.          {
  359.             _loc2_ = _loc2_.replace(flvplayback_internal::cuePointsReplace[_loc3_++],flvplayback_internal::cuePointsReplace[_loc3_++]);
  360.          }
  361.          return _loc2_;
  362.       }
  363.       
  364.       public function setFLVCuePointEnabled(param1:Boolean, param2:*) : int
  365.       {
  366.          var _loc3_:Object = null;
  367.          var _loc4_:Boolean = false;
  368.          var _loc5_:* = false;
  369.          var _loc6_:uint = 0;
  370.          var _loc7_:int = 0;
  371.          var _loc8_:int = 0;
  372.          var _loc9_:Object = null;
  373.          switch(typeof param2)
  374.          {
  375.             case "string":
  376.                _loc3_ = {"name":param2};
  377.                break;
  378.             case "number":
  379.                _loc3_ = {"time":param2};
  380.                break;
  381.             case "object":
  382.                _loc3_ = param2;
  383.          }
  384.          _loc4_ = isNaN(_loc3_.time) || _loc3_.time < 0;
  385.          _loc5_ = _loc3_.name == null;
  386.          if(_loc4_ && _loc5_)
  387.          {
  388.             throw new VideoError(VideoError.ILLEGAL_CUE_POINT,"time must be number and/or name must not be undefined or null");
  389.          }
  390.          _loc6_ = 0;
  391.          if(_loc4_)
  392.          {
  393.             if(!flvplayback_internal::_metadataLoaded)
  394.             {
  395.                if(flvplayback_internal::_disabledCuePointsByNameOnly[_loc3_.name] == undefined)
  396.                {
  397.                   if(!param1)
  398.                   {
  399.                      flvplayback_internal::_disabledCuePointsByNameOnly[_loc3_.name] = new Array();
  400.                   }
  401.                   removeCuePoints(flvplayback_internal::_disabledCuePoints,_loc3_);
  402.                   return -1;
  403.                }
  404.                if(param1)
  405.                {
  406.                   delete flvplayback_internal::_disabledCuePointsByNameOnly[_loc3_.name];
  407.                }
  408.                return -1;
  409.             }
  410.             if(param1)
  411.             {
  412.                _loc6_ = removeCuePoints(flvplayback_internal::_disabledCuePoints,_loc3_);
  413.             }
  414.             else
  415.             {
  416.                _loc7_ = flvplayback_internal::getCuePointIndex(flvplayback_internal::flvCuePoints,true,-1,_loc3_.name);
  417.                while(_loc7_ >= 0)
  418.                {
  419.                   _loc9_ = flvplayback_internal::flvCuePoints[_loc7_];
  420.                   if((_loc8_ = flvplayback_internal::getCuePointIndex(flvplayback_internal::_disabledCuePoints,true,_loc9_.time)) < 0 || flvplayback_internal::_disabledCuePoints[_loc8_].time != _loc9_.time)
  421.                   {
  422.                      flvplayback_internal::_disabledCuePoints = insertCuePoint(_loc8_,flvplayback_internal::_disabledCuePoints,{
  423.                         "name":_loc9_.name,
  424.                         "time":_loc9_.time
  425.                      });
  426.                      _loc6_ += 1;
  427.                   }
  428.                   _loc7_ = flvplayback_internal::getNextCuePointIndexWithName(_loc9_.name,flvplayback_internal::flvCuePoints,_loc7_);
  429.                }
  430.             }
  431.             return _loc6_;
  432.          }
  433.          if((_loc7_ = flvplayback_internal::getCuePointIndex(flvplayback_internal::_disabledCuePoints,false,_loc3_.time,_loc3_.name)) < 0)
  434.          {
  435.             if(param1)
  436.             {
  437.                if(!flvplayback_internal::_metadataLoaded)
  438.                {
  439.                   if((_loc7_ = flvplayback_internal::getCuePointIndex(flvplayback_internal::_disabledCuePoints,false,_loc3_.time)) < 0)
  440.                   {
  441.                      _loc8_ = flvplayback_internal::getCuePointIndex(flvplayback_internal::_disabledCuePointsByNameOnly[_loc3_.name],true,_loc3_.time);
  442.                      if(flvplayback_internal::cuePointCompare(_loc3_.time,null,flvplayback_internal::_disabledCuePointsByNameOnly[_loc3_.name]) != 0)
  443.                      {
  444.                         flvplayback_internal::_disabledCuePointsByNameOnly[_loc3_.name] = insertCuePoint(_loc8_,flvplayback_internal::_disabledCuePointsByNameOnly[_loc3_.name],_loc3_);
  445.                      }
  446.                   }
  447.                   else
  448.                   {
  449.                      flvplayback_internal::_disabledCuePoints.splice(_loc7_,1);
  450.                   }
  451.                }
  452.                return flvplayback_internal::_metadataLoaded ? 0 : -1;
  453.             }
  454.             if(flvplayback_internal::_metadataLoaded)
  455.             {
  456.                if((_loc7_ = flvplayback_internal::getCuePointIndex(flvplayback_internal::flvCuePoints,false,_loc3_.time,_loc3_.name)) < 0)
  457.                {
  458.                   return 0;
  459.                }
  460.                if(_loc5_)
  461.                {
  462.                   _loc3_.name = flvplayback_internal::flvCuePoints[_loc7_].name;
  463.                }
  464.             }
  465.             _loc8_ = flvplayback_internal::getCuePointIndex(flvplayback_internal::_disabledCuePoints,true,_loc3_.time);
  466.             flvplayback_internal::_disabledCuePoints = insertCuePoint(_loc8_,flvplayback_internal::_disabledCuePoints,_loc3_);
  467.             _loc6_ = 1;
  468.             return flvplayback_internal::_metadataLoaded ? int(_loc6_) : -1;
  469.          }
  470.          if(param1)
  471.          {
  472.             flvplayback_internal::_disabledCuePoints.splice(_loc7_,1);
  473.             _loc6_ = 1;
  474.          }
  475.          else
  476.          {
  477.             _loc6_ = 0;
  478.          }
  479.          return flvplayback_internal::_metadataLoaded ? int(_loc6_) : -1;
  480.       }
  481.       
  482.       public function isFLVCuePointEnabled(param1:*) : Boolean
  483.       {
  484.          var _loc2_:Object = null;
  485.          var _loc3_:Boolean = false;
  486.          var _loc4_:* = false;
  487.          var _loc5_:int = 0;
  488.          if(!flvplayback_internal::_metadataLoaded)
  489.          {
  490.             return true;
  491.          }
  492.          switch(typeof param1)
  493.          {
  494.             case "string":
  495.                _loc2_ = {"name":param1};
  496.                break;
  497.             case "number":
  498.                _loc2_ = {"time":param1};
  499.                break;
  500.             case "object":
  501.                _loc2_ = param1;
  502.          }
  503.          _loc3_ = isNaN(_loc2_.time) || _loc2_.time < 0;
  504.          _loc4_ = _loc2_.name == null;
  505.          if(_loc3_ && _loc4_)
  506.          {
  507.             throw new VideoError(VideoError.ILLEGAL_CUE_POINT,"time must be number and/or name must not be undefined or null");
  508.          }
  509.          if(_loc3_)
  510.          {
  511.             if((_loc5_ = flvplayback_internal::getCuePointIndex(flvplayback_internal::flvCuePoints,true,-1,_loc2_.name)) < 0)
  512.             {
  513.                return true;
  514.             }
  515.             while(_loc5_ >= 0)
  516.             {
  517.                if(flvplayback_internal::getCuePointIndex(flvplayback_internal::_disabledCuePoints,false,flvplayback_internal::flvCuePoints[_loc5_].time,flvplayback_internal::flvCuePoints[_loc5_].name) < 0)
  518.                {
  519.                   return true;
  520.                }
  521.                _loc5_ = flvplayback_internal::getNextCuePointIndexWithName(_loc2_.name,flvplayback_internal::flvCuePoints,_loc5_);
  522.             }
  523.             return false;
  524.          }
  525.          return flvplayback_internal::getCuePointIndex(flvplayback_internal::_disabledCuePoints,false,_loc2_.time,_loc2_.name) < 0;
  526.       }
  527.       
  528.       public function removeASCuePoint(param1:*) : Object
  529.       {
  530.          var _loc2_:Object = null;
  531.          var _loc3_:int = 0;
  532.          if(flvplayback_internal::asCuePoints == null || flvplayback_internal::asCuePoints.length < 1)
  533.          {
  534.             return null;
  535.          }
  536.          switch(typeof param1)
  537.          {
  538.             case "string":
  539.                _loc2_ = {"name":param1};
  540.                break;
  541.             case "number":
  542.                _loc2_ = {"time":param1};
  543.                break;
  544.             case "object":
  545.                _loc2_ = param1;
  546.          }
  547.          _loc3_ = flvplayback_internal::getCuePointIndex(flvplayback_internal::asCuePoints,false,_loc2_.time,_loc2_.name);
  548.          if(_loc3_ < 0)
  549.          {
  550.             return null;
  551.          }
  552.          _loc2_ = flvplayback_internal::asCuePoints[_loc3_];
  553.          flvplayback_internal::asCuePoints.splice(_loc3_,1);
  554.          _loc3_ = flvplayback_internal::getCuePointIndex(flvplayback_internal::allCuePoints,false,_loc2_.time,_loc2_.name);
  555.          if(_loc3_ > 0)
  556.          {
  557.             flvplayback_internal::allCuePoints.splice(_loc3_,1);
  558.          }
  559.          if(_owner.getVideoPlayer(flvplayback_internal::_id).playheadTime > 0)
  560.          {
  561.             if(flvplayback_internal::_asCuePointIndex > _loc3_)
  562.             {
  563.                --flvplayback_internal::_asCuePointIndex;
  564.             }
  565.          }
  566.          else
  567.          {
  568.             flvplayback_internal::_asCuePointIndex = 0;
  569.          }
  570.          return _loc2_;
  571.       }
  572.       
  573.       public function get id() : uint
  574.       {
  575.          return flvplayback_internal::_id;
  576.       }
  577.       
  578.       public function processCuePointsProperty(param1:Array) : void
  579.       {
  580.          var _loc2_:uint = 0;
  581.          var _loc3_:uint = 0;
  582.          var _loc4_:String = null;
  583.          var _loc5_:String = null;
  584.          var _loc6_:Object = null;
  585.          var _loc7_:* = false;
  586.          var _loc8_:int = 0;
  587.          if(param1 == null || param1.length == 0)
  588.          {
  589.             return;
  590.          }
  591.          _loc2_ = 0;
  592.          _loc8_ = 0;
  593.          while(_loc8_ < param1.length - 1)
  594.          {
  595.             switch(_loc2_)
  596.             {
  597.                case 6:
  598.                   flvplayback_internal::addOrDisable(_loc7_,_loc6_);
  599.                   _loc2_ = 0;
  600.                case 0:
  601.                   if(param1[_loc8_++] != "t")
  602.                   {
  603.                      throw new VideoError(VideoError.ILLEGAL_CUE_POINT,"unexpected cuePoint parameter format");
  604.                   }
  605.                   if(isNaN(param1[_loc8_]))
  606.                   {
  607.                      throw new VideoError(VideoError.ILLEGAL_CUE_POINT,"time must be number");
  608.                   }
  609.                   break;
  610.                case 1:
  611.                   if(param1[_loc8_++] != "n")
  612.                   {
  613.                      throw new VideoError(VideoError.ILLEGAL_CUE_POINT,"unexpected cuePoint parameter format");
  614.                   }
  615.                   if(param1[_loc8_] == undefined)
  616.                   {
  617.                      throw new VideoError(VideoError.ILLEGAL_CUE_POINT,"name cannot be null or undefined");
  618.                   }
  619.                   _loc6_.name = unescape(param1[_loc8_]);
  620.                   _loc2_++;
  621.                   break;
  622.                case 2:
  623.                   if(param1[_loc8_++] != "t")
  624.                   {
  625.                      throw new VideoError(VideoError.ILLEGAL_CUE_POINT,"unexpected cuePoint parameter format");
  626.                   }
  627.                   if(isNaN(param1[_loc8_]))
  628.                   {
  629.                      throw new VideoError(VideoError.ILLEGAL_CUE_POINT,"type must be number");
  630.                   }
  631.                   switch(param1[_loc8_])
  632.                   {
  633.                      case 0:
  634.                         _loc6_.type = CuePointType.EVENT;
  635.                         break;
  636.                      case 1:
  637.                         _loc6_.type = CuePointType.NAVIGATION;
  638.                         break;
  639.                      case 2:
  640.                         _loc6_.type = CuePointType.ACTIONSCRIPT;
  641.                         break;
  642.                      default:
  643.                         throw new VideoError(VideoError.ILLEGAL_CUE_POINT,"type must be 0, 1 or 2");
  644.                   }
  645.                   _loc2_++;
  646.                   break;
  647.                case 3:
  648.                   if(param1[_loc8_++] != "d")
  649.                   {
  650.                      throw new VideoError(VideoError.ILLEGAL_CUE_POINT,"unexpected cuePoint parameter format");
  651.                   }
  652.                   if(isNaN(param1[_loc8_]))
  653.                   {
  654.                      throw new VideoError(VideoError.ILLEGAL_CUE_POINT,"disabled must be number");
  655.                   }
  656.                   _loc7_ = param1[_loc8_] != 0;
  657.                   _loc2_++;
  658.                   break;
  659.                case 4:
  660.                   if(param1[_loc8_++] != "p")
  661.                   {
  662.                      throw new VideoError(VideoError.ILLEGAL_CUE_POINT,"unexpected cuePoint parameter format");
  663.                   }
  664.                   if(isNaN(param1[_loc8_]))
  665.                   {
  666.                      throw new VideoError(VideoError.ILLEGAL_CUE_POINT,"num params must be number");
  667.                   }
  668.                   _loc3_ = uint(param1[_loc8_]);
  669.                   _loc2_++;
  670.                   if(_loc3_ == 0)
  671.                   {
  672.                      _loc2_++;
  673.                   }
  674.                   else
  675.                   {
  676.                      _loc6_.parameters = new Object();
  677.                   }
  678.                   break;
  679.                case 5:
  680.                   _loc4_ = String(param1[_loc8_++]);
  681.                   _loc5_ = String(param1[_loc8_]);
  682.                   if(_loc4_ is String)
  683.                   {
  684.                      _loc4_ = unescape(_loc4_);
  685.                   }
  686.                   if(_loc5_ is String)
  687.                   {
  688.                      _loc5_ = unescape(_loc5_);
  689.                   }
  690.                   _loc6_.parameters[_loc4_] = _loc5_;
  691.                   _loc3_--;
  692.                   if(_loc3_ == 0)
  693.                   {
  694.                      _loc2_++;
  695.                   }
  696.                   break;
  697.             }
  698.             (_loc6_ = new Object()).time = param1[_loc8_] / 1000;
  699.             _loc2_++;
  700.             _loc8_++;
  701.          }
  702.          if(_loc2_ == 6)
  703.          {
  704.             flvplayback_internal::addOrDisable(_loc7_,_loc6_);
  705.             return;
  706.          }
  707.          throw new VideoError(VideoError.ILLEGAL_CUE_POINT,"unexpected end of cuePoint param string");
  708.       }
  709.       
  710.       flvplayback_internal function getNextCuePointIndexWithName(param1:String, param2:Array, param3:int) : int
  711.       {
  712.          var _loc4_:int = 0;
  713.          if(param1 == null)
  714.          {
  715.             throw new VideoError(VideoError.ILLEGAL_CUE_POINT,"name cannot be undefined or null");
  716.          }
  717.          if(param2 == null)
  718.          {
  719.             throw new VideoError(VideoError.ILLEGAL_CUE_POINT,"cuePoint.array undefined");
  720.          }
  721.          if(isNaN(param3) || param3 < -1 || param3 >= param2.length)
  722.          {
  723.             throw new VideoError(VideoError.ILLEGAL_CUE_POINT,"cuePoint.index must be number between -1 and cuePoint.array.length");
  724.          }
  725.          _loc4_ = param3 + 1;
  726.          while(_loc4_ < param2.length)
  727.          {
  728.             if(param2[_loc4_].name == param1)
  729.             {
  730.                break;
  731.             }
  732.             _loc4_++;
  733.          }
  734.          if(_loc4_ < param2.length)
  735.          {
  736.             return _loc4_;
  737.          }
  738.          return -1;
  739.       }
  740.       
  741.       public function dispatchASCuePoints() : void
  742.       {
  743.          var _loc1_:Number = NaN;
  744.          _loc1_ = _owner.getVideoPlayer(flvplayback_internal::_id).playheadTime;
  745.          if(_owner.getVideoPlayer(flvplayback_internal::_id).stateResponsive && flvplayback_internal::asCuePoints != null)
  746.          {
  747.             while(flvplayback_internal::_asCuePointIndex < flvplayback_internal::asCuePoints.length && flvplayback_internal::asCuePoints[flvplayback_internal::_asCuePointIndex].time <= _loc1_ + flvplayback_internal::_asCuePointTolerance)
  748.             {
  749.                _owner.dispatchEvent(new MetadataEvent(MetadataEvent.CUE_POINT,false,false,flvplayback_internal::deepCopyObject(flvplayback_internal::asCuePoints[flvplayback_internal::_asCuePointIndex++]),flvplayback_internal::_id));
  750.             }
  751.          }
  752.       }
  753.       
  754.       flvplayback_internal function getNextCuePointWithName(param1:Object) : Object
  755.       {
  756.          var _loc2_:int = 0;
  757.          var _loc3_:Object = null;
  758.          if(param1 == null)
  759.          {
  760.             throw new VideoError(VideoError.ILLEGAL_CUE_POINT,"cuePoint parameter undefined");
  761.          }
  762.          if(isNaN(param1.time) || param1.time < 0)
  763.          {
  764.             throw new VideoError(VideoError.ILLEGAL_CUE_POINT,"time must be number");
  765.          }
  766.          _loc2_ = flvplayback_internal::getNextCuePointIndexWithName(param1.name,param1.array,param1.index);
  767.          if(_loc2_ < 0)
  768.          {
  769.             return null;
  770.          }
  771.          _loc3_ = flvplayback_internal::deepCopyObject(param1.array[_loc2_]);
  772.          _loc3_.array = param1.array;
  773.          _loc3_.index = _loc2_;
  774.          return _loc3_;
  775.       }
  776.       
  777.       public function insertCuePoint(param1:int, param2:Array, param3:Object) : Array
  778.       {
  779.          if(param1 < 0)
  780.          {
  781.             param2 = new Array();
  782.             param2.push(param3);
  783.          }
  784.          else
  785.          {
  786.             if(param2[param1].time > param3.time)
  787.             {
  788.                param1 = 0;
  789.             }
  790.             else
  791.             {
  792.                param1++;
  793.             }
  794.             param2.splice(param1,0,param3);
  795.          }
  796.          return param2;
  797.       }
  798.       
  799.       flvplayback_internal function getCuePointIndex(param1:Array, param2:Boolean, param3:Number = NaN, param4:String = null, param5:int = -1, param6:int = -1) : int
  800.       {
  801.          var _loc7_:Boolean = false;
  802.          var _loc8_:* = false;
  803.          var _loc9_:int = 0;
  804.          var _loc10_:int = 0;
  805.          var _loc11_:int = 0;
  806.          var _loc12_:int = 0;
  807.          var _loc13_:int = 0;
  808.          var _loc14_:int = 0;
  809.          var _loc15_:int = 0;
  810.          if(param1 == null || param1.length < 1)
  811.          {
  812.             return -1;
  813.          }
  814.          _loc7_ = isNaN(param3) || param3 < 0;
  815.          _loc8_ = param4 == null;
  816.          if(_loc7_ && _loc8_)
  817.          {
  818.             throw new VideoError(VideoError.ILLEGAL_CUE_POINT,"time must be number and/or name must not be undefined or null");
  819.          }
  820.          if(param5 < 0)
  821.          {
  822.             param5 = 0;
  823.          }
  824.          if(param6 < 0)
  825.          {
  826.             param6 = int(param1.length);
  827.          }
  828.          if(!_loc8_ && (param2 || _loc7_))
  829.          {
  830.             if(_loc7_)
  831.             {
  832.                _loc12_ = param5;
  833.             }
  834.             else
  835.             {
  836.                _loc12_ = flvplayback_internal::getCuePointIndex(param1,param2,param3);
  837.             }
  838.             _loc13_ = _loc12_;
  839.             while(_loc13_ >= param5)
  840.             {
  841.                if(param1[_loc13_].name == param4)
  842.                {
  843.                   break;
  844.                }
  845.                _loc13_--;
  846.             }
  847.             if(_loc13_ >= param5)
  848.             {
  849.                return _loc13_;
  850.             }
  851.             _loc13_ = _loc12_ + 1;
  852.             while(_loc13_ < param6)
  853.             {
  854.                if(param1[_loc13_].name == param4)
  855.                {
  856.                   break;
  857.                }
  858.                _loc13_++;
  859.             }
  860.             if(_loc13_ < param6)
  861.             {
  862.                return _loc13_;
  863.             }
  864.             return -1;
  865.          }
  866.          if(param6 <= flvplayback_internal::_linearSearchTolerance)
  867.          {
  868.             _loc14_ = param5 + param6;
  869.             _loc15_ = param5;
  870.             while(_loc15_ < _loc14_)
  871.             {
  872.                if((_loc9_ = flvplayback_internal::cuePointCompare(param3,param4,param1[_loc15_])) == 0)
  873.                {
  874.                   return _loc15_;
  875.                }
  876.                if(_loc9_ < 0)
  877.                {
  878.                   break;
  879.                }
  880.                _loc15_++;
  881.             }
  882.             if(param2)
  883.             {
  884.                if(_loc15_ > 0)
  885.                {
  886.                   return _loc15_ - 1;
  887.                }
  888.                return 0;
  889.             }
  890.             return -1;
  891.          }
  892.          _loc10_ = int(param6 / 2);
  893.          _loc11_ = param5 + _loc10_;
  894.          if((_loc9_ = flvplayback_internal::cuePointCompare(param3,param4,param1[_loc11_])) < 0)
  895.          {
  896.             return flvplayback_internal::getCuePointIndex(param1,param2,param3,param4,param5,_loc10_);
  897.          }
  898.          if(_loc9_ > 0)
  899.          {
  900.             return flvplayback_internal::getCuePointIndex(param1,param2,param3,param4,_loc11_ + 1,_loc10_ - 1 + param6 % 2);
  901.          }
  902.          return _loc11_;
  903.       }
  904.    }
  905. }
  906.